home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 8: LINUX Games / Linux Cubed Series 8 - LINUX Games.iso / games / x11 / rpg / crossfir.92 / crossfir / crossfire-0.92.5 / server / gods.c < prev    next >
C/C++ Source or Header  |  1996-07-24  |  12KB  |  380 lines
  1. /*
  2.  * static char *rcsid_apply_c =
  3.  *   "$Id: gods.c,v 1.4 1996/07/24 07:37:10 master Exp master $";
  4.  */
  5. /*
  6.     CrossFire, A Multiplayer game for X-windows
  7.  
  8.     Copyright (C) 1994 Mark Wedel
  9.     Copyright (C) 1992 Frank Tore Johansen
  10.  
  11.     This program is free software; you can redistribute it and/or modify
  12.     it under the terms of the GNU General Public License as published by
  13.     the Free Software Foundation; either version 2 of the License, or
  14.     (at your option) any later version.
  15.  
  16.     This program is distributed in the hope that it will be useful,
  17.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  18.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19.     GNU General Public License for more details.
  20.  
  21.     You should have received a copy of the GNU General Public License
  22.     along with this program; if not, write to the Free Software
  23.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  24.  
  25.     The author can be reached via e-mail to mwedel@pyramid.com
  26. */
  27.  
  28.  
  29. /* Oct 3, 1995 - Code laid down for initial gods, priest alignment, and 
  30.  * monster race initialization. b.t.
  31.  */
  32.  
  33. #include <global.h>
  34. #include <living.h>
  35. #include <object.h>
  36. #include <spells.h>
  37. #include <sounds.h>
  38. #ifndef __CEXTRACT__
  39. #include <sproto.h>
  40. #endif
  41.  
  42. int 
  43. lookup_god_by_name(char *name) {
  44.   int godnr=0;
  45.   int nmlen = strlen(name);
  46.  
  47.   if(name==NULL || !strcmp(name,"none")) return -1;
  48.   while(strncmp(name,Gods[godnr].name,MIN(strlen(Gods[godnr].name),nmlen))
  49.           && godnr < (NROFGODS - 1)) {
  50.         godnr++;
  51.   }
  52.  
  53.   if(godnr==NROFGODS) godnr=-1;
  54.   return godnr;
  55. }
  56.  
  57. void become_follower (object *op, char *godname) {
  58.   object *exp_obj = op->chosen_skill->exp_obj;
  59.   int godnr = lookup_god_by_name(godname);
  60.  
  61.     if(godnr<0) return;
  62.  
  63.     new_draw_info_format(NDI_UNIQUE|NDI_NAVY,0,op,
  64.        "You become a follower of %s!",godname);
  65.     if(exp_obj->title) { /* get rid of old god */ 
  66.        new_draw_info_format(NDI_UNIQUE,0,op,
  67.            "%s's blessing is withdrawn from you.",exp_obj->title);
  68.        CLEAR_FLAG(exp_obj,FLAG_APPLIED); 
  69.        (void) change_abil(op,exp_obj);
  70.         free_string(exp_obj->title);
  71.     }
  72.  
  73.    /* now change to the new gods attributes to exp_obj */
  74.     exp_obj->title = add_string(godname);
  75.     exp_obj->protected=Gods[godnr].protected; 
  76.     exp_obj->vulnerable=Gods[godnr].vulnerable; 
  77.     exp_obj->path_attuned=Gods[godnr].path_attuned;
  78.     exp_obj->path_repelled=Gods[godnr].path_repelled;
  79.     exp_obj->path_denied=Gods[godnr].path_denied;
  80.  
  81.     new_draw_info_format(NDI_UNIQUE,0,op,
  82.            "You are bathed in %s's aura.",godname);
  83.  
  84.     SET_FLAG(exp_obj,FLAG_APPLIED); 
  85.     (void) change_abil(op,exp_obj);
  86.  
  87. } 
  88.  
  89. /* determine_god() - determines if op worships a god. Returns
  90.  * the godname if they do. In the case of an NPC, if they have
  91.  * no god, we give them a random one. -b.t. 
  92.  */
  93.  
  94. char *determine_god(object *op) {
  95.   int godnr = -1;
  96.  
  97.   if(op->type!= PLAYER && !op->title && QUERY_FLAG(op,FLAG_ALIVE)) { 
  98.       godnr = RANDOM()%NROFGODS; 
  99.       return ((op->title = add_string(Gods[godnr].name)));
  100.   } else {
  101.     if((op->type==PLAYER && op->chosen_skill 
  102.       && op->chosen_skill->exp_obj && op->chosen_skill->exp_obj->title))
  103.            return  op->chosen_skill->exp_obj->title;
  104.   }
  105.   return ("none");
  106. } 
  107.  
  108.  
  109. /* god_intervention() - called from praying() currently. Every
  110.  * once in a while the god will intervene to help the worshiper.
  111.  * Later, this fctn can be used to supply quests, etc for the 
  112.  * priest. -b.t. 
  113.  */
  114.  
  115. void god_intervention(object *op, char *godname) {
  116.   int godnr = lookup_god_by_name(godname); 
  117.   int level=SK_level(op);
  118.  
  119.   /*safety, shouldnt happen */
  120.   if(godnr==-1) return;
  121.  
  122.   new_draw_info(NDI_UNIQUE|NDI_UNIQUE,0,op,"You feel a holy presence!");
  123.  
  124.   /* So, what can we do to help out? We do some minimal checking
  125.    * of the god's attributes to ensure there is a bit of consistency
  126.    * between what happens and what the god can do. We do benefits 
  127.    * in 2 sections. In the first, we check if the god can fix
  128.    * problems of the priest. In the second, rare boons are given.
  129.    * In either case, as soon as the god gives a gift, we return */
  130.  
  131.  
  132.   /* FIRST SECTION */
  133.  
  134.   /* Restore the priest to a better state of grace. */ 
  135.   if(op->stats.grace<0) {
  136.         new_draw_info(NDI_UNIQUE,0,op,"You are returned to a state of grace.");
  137.     op->stats.grace=RANDOM()%10;
  138.     return;
  139.   } 
  140.  
  141.  /* Heal damage */
  142.   if(!(Gods[godnr].path_denied&PATH_RESTORE)) { 
  143.      if(op->stats.hp<op->stats.maxhp) { 
  144.     op->stats.hp=op->stats.maxhp;
  145.         new_draw_info(NDI_UNIQUE,0,op,"A white light surrounds and heals you!");
  146.     return;
  147.      }
  148.   }
  149.  
  150.  /* cure confusion? */
  151.   if(!(Gods[godnr].attacktype&AT_CONFUSION))
  152.     if(cast_heal(op,0,SP_CURE_CONFUSION)) return;
  153.  
  154.  /* remove poison? */
  155.   if(!(Gods[godnr].attacktype&AT_POISON))
  156.     if(cast_heal(op,0,SP_CURE_POISON)) return;
  157.  
  158.  /* Remove cursed/damned items? This is better than the spell, here we
  159.   * allow unapplied items to be uncursed */
  160.   if(!(RANDOM()%2)&&!(Gods[godnr].path_denied&PATH_TURNING)) {
  161.     object *tmp;
  162.     int success = 0;
  163.  
  164.     for (tmp = op->inv; tmp; tmp = tmp->below)
  165.       if (QUERY_FLAG(tmp, FLAG_CURSED)||QUERY_FLAG(tmp, FLAG_DAMNED)) {
  166.           success++;
  167.           if(QUERY_FLAG(tmp, FLAG_DAMNED)) CLEAR_FLAG(tmp, FLAG_DAMNED);
  168.           CLEAR_FLAG(tmp, FLAG_CURSED);
  169.           CLEAR_FLAG(tmp, FLAG_KNOWN_CURSED);
  170.           if (op->type == PLAYER && op->contr->eric_server > 0)
  171.                   esrv_send_item(op, tmp);
  172.        }  
  173.     if (op->type==PLAYER&&success) {
  174.     new_draw_info(NDI_UNIQUE, 0,op, "You feel like someone is helping you.");
  175.     draw_inventory(op);
  176.     return;
  177.     }
  178.   }
  179.  
  180.   /* Fix drained stats? */
  181.   if(!(RANDOM()%2)&&!(Gods[godnr].attacktype&AT_DRAIN)) {
  182.      object *depl;
  183.      archetype *at;
  184.  
  185.      if ((at = find_archetype("depletion"))==NULL) {
  186.         LOG(llevError,"Could not find archetype depletion");
  187.         return;
  188.      }  
  189.      depl = present_arch_in_ob(at, op);
  190.      if (depl!=NULL) {   
  191.         int i;
  192.         new_draw_info(NDI_UNIQUE,0,op,"Shimmering light surrounds and restores you!");
  193.         for (i = 0; i < 7; i++)
  194.             if (get_attr_value(&depl->stats, i)) {
  195.               new_draw_info(NDI_UNIQUE,0,op, restore_msg[i]);
  196.             }
  197.     remove_ob(depl);
  198.     free_object(depl);
  199.         fix_player(op);
  200.         return;
  201.      }
  202.   }
  203.   
  204.   /* Special knowledge of the God? */
  205.   if((!RANDOM()%10)&&!(Gods[godnr].path_denied&PATH_INFO)) { 
  206.       if(strcmp(Gods[godnr].enemy_race,"none")) {
  207.           new_draw_info_format(NDI_UNIQUE,0,op,
  208.         "You are filled with a desire to slay all things which are %s.",
  209.         Gods[godnr].enemy_race);
  210.       return;
  211.       } else if(strcmp(Gods[godnr].aligned_race,"none")) {
  212.           new_draw_info_format(NDI_UNIQUE,0,op,
  213.         "You are feel a bond with all things which are %s.",
  214.         Gods[godnr].aligned_race);
  215.       return;
  216.       } 
  217.   }
  218.  
  219.   /* SECOND SECTION */
  220.  
  221.   /* Now, for the special section. If the priest is in a "state of grace"
  222.    * (ie grace.stats>100&&grace>maxgrace) we get one of the good benefits
  223.    * else, just a "super-blessing" via "holy possession" spell */
  224.  
  225.   /* blessing via "holy possesion" spell */
  226.   if((op->stats.grace<80)||(op->stats.grace<op->stats.maxgrace)) {
  227.      (void) cast_change_attr(op,0,SP_HOLY_POSSESSION);
  228.      return;
  229.   }
  230.  
  231.   /* Enchant/bless your weapon upto priest level/5  */
  232.   if(!(RANDOM()%2)&&QUERY_FLAG(op,FLAG_READY_WEAPON)) {
  233.     object *weapon=NULL;
  234.  
  235.     for(weapon=op->inv;weapon;weapon=weapon->below) 
  236.        if(weapon->type==WEAPON&&QUERY_FLAG(weapon,FLAG_APPLIED)) break;
  237.  
  238.     /* allow the weapon to slay enemies */
  239.     if(weapon && !weapon->slaying&&strcmp("none",Gods[godnr].enemy_race)) {
  240.         char buf[MAX_BUF];
  241.  
  242.     weapon->slaying = add_string(Gods[godnr].enemy_race); 
  243.         new_draw_info(NDI_UNIQUE,0,op,"Your weapon quivers as if struck!"); 
  244.     if(!weapon->title) {
  245.           new_draw_info_format(NDI_UNIQUE,0,op,
  246.              "Your %s now hungers to slay enemies of your god!",
  247.          weapon->name);
  248.       sprintf(buf,"of %s",godname);
  249.       weapon->title=add_string(buf);
  250.           if(op->type==PLAYER) draw_inventory(op);
  251.     }
  252.     return;
  253.     }
  254.  
  255.     /* add the gods attacktype*/
  256.     if(weapon && !(RANDOM()%2)&&!(weapon->attacktype&Gods[godnr].attacktype)) {
  257.         new_draw_info(NDI_UNIQUE,0,op,"Your weapon suddenly glows!");
  258.     weapon->attacktype=weapon->attacktype|Gods[godnr].attacktype;
  259.     return;
  260.     }
  261.  
  262.     /* higher magic value */
  263.     if(weapon && !(RANDOM()%2)&&weapon->magic<(level/5)) {
  264.        new_draw_info(NDI_UNIQUE,0,op,
  265.           "A phosphorescent glow envelops your weapon!");
  266.        weapon->magic++;
  267.        if(op->type==PLAYER) draw_inventory(op);
  268.        return;
  269.     }
  270.   }
  271.  
  272.  /* If they qualify, grant the priest use of a special spell */
  273.  
  274.   if(op->stats.Wis&&op->stats.Wis>25) { 
  275.     int spell=0;
  276.  
  277.    /*generate a random rare clerical spell*/  
  278.     do {
  279.     spell=RANDOM()%NROFREALSPELLS;
  280.     } while(spells[spell].books && !spells[spell].cleric);
  281.  
  282.  
  283.    /* The god will only teach the spell if its not against the nature
  284.     * of the cult, the priest is high enough in level *and* the priest
  285.     * doesnt already know it */
  286.    /* Also, there are some spells which can really disturb playbalance,
  287.     * to keep these out of player hands, we discard any spell which 
  288.     * has PATH_NULL.  
  289.     */
  290.  
  291.     if(!(Gods[godnr].path_denied&spells[spell].path) 
  292.         &&!(Gods[godnr].path_repelled&spells[spell].path) 
  293.     &&!(spells[spell].path&PATH_NULL)
  294.     &&spells[spell].level<=level
  295.     &&!check_spell_known(op,spell)) { 
  296.  
  297. #ifdef SOUND_EFFECTS 
  298.         play_sound_player_only(op->contr, SOUND_LEARN_SPELL); 
  299. #endif   
  300.         new_draw_info_format(NDI_UNIQUE, 0,op,
  301.         "%s grants you use of a special prayer!",godname); 
  302.         op->contr->known_spells[op->contr->nrofknownspells++]=spell; 
  303.         if(op->contr->nrofknownspells == 1) 
  304.             op->contr->chosen_spell=spell; 
  305.         new_draw_info_format(NDI_UNIQUE, 0, op, 
  306.             "Type 'bind cast %s",spells[spell].name); 
  307.         new_draw_info(NDI_UNIQUE, 0,op,"to store the spell in a key."); 
  308.         return;
  309.     } 
  310.   } 
  311.    
  312. /* Last message, sorry charlie, nothing was given except good vibes :) */
  313.   new_draw_info(NDI_UNIQUE, 0,op,"You feel rapture."); 
  314.  
  315. }
  316.  
  317. /* get_god() - returns the gods index in Gods[] array, if the god
  318.  * exists, if not, it returns -1. -b.t.
  319.  */
  320.  
  321. int get_god(object *priest) {
  322.   int godnr=lookup_god_by_name(determine_god(priest)); 
  323.  
  324.   return godnr;
  325. }
  326.  
  327.  
  328. /* tailor_god_spell() - changes the attributes of cone, smite, 
  329.  * and ball spells as needed by the code. Returns false if there
  330.  * was no race to assign to the slaying field of the spell, but
  331.  * the spell attacktype contains AT_HOLYWORD.  -b.t.
  332.  */
  333.  
  334. int tailor_god_spell(object *spellop, object *caster, int godnr) {
  335.     int caster_is_spell=0; 
  336.  
  337.     if(caster->type==FBULLET
  338.        ||caster->type==CONE
  339.        ||caster->type==FBALL) caster_is_spell=1; 
  340.  
  341.     if(!caster_is_spell)
  342.         if(godnr<0||((spellop->attacktype&AT_HOLYWORD)&&
  343.              !strcmp(Gods[godnr].enemy_race,"none"))) {
  344.           new_draw_info(NDI_UNIQUE, 0, caster,
  345.             "This prayer is useless unless you worship an appropriate god");
  346.           free_object(spellop);
  347.           return 0;
  348.         }
  349.  
  350.     /* either holy word or godpower attacks will set the slaying field */
  351.     if(spellop->attacktype&AT_HOLYWORD||spellop->attacktype&AT_GODPOWER) { 
  352.          if(spellop->slaying) free_string(spellop->slaying);
  353.          if(!caster_is_spell)
  354.             spellop->slaying = add_string(Gods[godnr].enemy_race);
  355.      else if(caster->slaying) 
  356.         spellop->slaying = add_string(caster->slaying);
  357.     }
  358.  
  359.     /* only the godpower attacktype adds the god's attack onto the spell */
  360.     if((spellop->attacktype&AT_GODPOWER)&&!caster_is_spell) 
  361.          spellop->attacktype=spellop->attacktype|Gods[godnr].attacktype;
  362.  
  363.     /* a little cosmetic for fun, we tack on the god's name to the spell */
  364.     if(spellop->attacktype&AT_HOLYWORD||spellop->attacktype&AT_GODPOWER) { 
  365.          if(spellop->title) free_string(spellop->title);
  366.          if(caster_is_spell&&caster->title) 
  367.            spellop->title=add_string(caster->title);
  368.          else if((godnr=get_god(caster))!=-1) 
  369.            spellop->title=add_string(Gods[godnr].name);
  370.          if(spellop->title){
  371.        char buf[MAX_BUF]; 
  372.        sprintf(buf,"%s of %s",spellop->name,spellop->title);
  373.        spellop->name=add_string(buf);
  374.     }
  375.     } 
  376.  
  377.     return 1;
  378. }
  379.  
  380.